package qc.module.ehs.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import qc.common.core.enums.EhsEpibolyStatusEnum;
import qc.common.core.exception.QCPromptException;
import qc.common.core.unify.QCUnifyReturnValue;
import qc.common.core.utils.IdentifierUtil;
import qc.module.ehs.dto.epibolyperson.EpibolyPersonDto;
import qc.module.ehs.entity.EhsEpibolyPerson;
import qc.module.ehs.entity.EhsEpibolyUnit;
import qc.module.ehs.mapper.EhsEpibolyPersonMapper;
import qc.module.ehs.repository.EhsEpibolyPersonRepository;
import qc.module.ehs.repository.EhsEpibolyUnitRepository;

import java.util.List;
import java.util.Objects;

/**
 * 相关方人员信息表;(EHS_EPIBOLY_PERSON)表服务接口
 * @author : http://www.chiner.pro
 * @date : 2025-3-12
 */
@Service
public class EhsEpibolyPersonService {

    @Autowired
    private EhsEpibolyPersonRepository repository;

    @Autowired
    private EhsEpibolyUnitRepository unitRepository;

    /**
     * 根据相关方单位查询相关人员信息
     * @param id 指定的单位id
     * @return List<EpibolyPersonDto>
     */
    public List<EpibolyPersonDto> getByUnit(String id) throws QCPromptException {
        //1、判断查询
        if (StringUtils.isBlank(id)) throw new QCPromptException("查询单位id不能为空");

        //2、添加单位查询条件
        LambdaQueryWrapper<EhsEpibolyPerson> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsEpibolyPerson::getUnitid, id);

        wrapper.orderByAsc(EhsEpibolyPerson::getName);
        List<EhsEpibolyPerson> ens = repository.selectList(wrapper);
        if (CollectionUtils.isNotEmpty(ens)) {
            return EhsEpibolyPersonMapper.MAPPER.toDtoList(ens);
        }
        return null;
    }

    /**
     * 添加相关人员信息
     * @param dto 添加的信息
     * @return null为成功，失败返回提示信息
     */
    public String add(EpibolyPersonDto dto) {
        //1、dto验证
        if (dto == null) return QCUnifyReturnValue.Warn("相关方人员的添加信息不能为空");
        if (StringUtils.isBlank(dto.getName())) return QCUnifyReturnValue.Warn("相关方人员的名字不能为空");
        if (StringUtils.isBlank(dto.getUnitid())) return QCUnifyReturnValue.Warn("相关方人员的单位不能为空");
        if (StringUtils.isBlank(dto.getOrgcode())) return QCUnifyReturnValue.Warn("相关方人员的组织代码不能为空");

        //2、验证单位
        EhsEpibolyUnit unit = unitRepository.selectById(dto.getUnitid());
        if (Objects.isNull(unit)) return QCUnifyReturnValue.Warn("添加的相关单位不存在");

        //3、身份证校验
        if (StringUtils.isNotBlank(dto.getIdnumber())) {
            if (hasIdnumberExist(dto.getIdnumber(), null)) {
                return QCUnifyReturnValue.Warn("相关方人员的身份证信息已存在");
            }
        }

        //4、判断手机号
        if (StringUtils.isNotBlank(dto.getPhone())) {
            if (hasPhoneExist(dto.getPhone(), null)) {
                return QCUnifyReturnValue.Warn("相关方人员的手机号已存在");
            }
        }

        //5、dto->entity
        EhsEpibolyPerson en = EhsEpibolyPersonMapper.MAPPER.dtoToEntity(dto);
        en.setId(IdentifierUtil.randomUUID());
        en.setName(dto.getName());
        if (repository.insert(en) < 0x1) {
            return QCUnifyReturnValue.Warn("相关方人员添加信息失败");
        }
        return QCUnifyReturnValue.Success();
    }

    /**
     * 修改相关人员信息
     * @param dto 修改的信息
     * @return null为成功，失败返回提示信息
     */
    public String update(EpibolyPersonDto dto) {
        //1、dto验证
        if (dto == null) return QCUnifyReturnValue.Warn("相关方人员的修改信息不能为空");
        if (StringUtils.isBlank(dto.getUnitid())) return QCUnifyReturnValue.Warn("相关方人员的单位id不能为空");
        if (StringUtils.isBlank(dto.getOrgcode())) return QCUnifyReturnValue.Warn("相关方人员的组织代码不能为空");

        //2、验证人员id
        EhsEpibolyPerson en = repository.selectById(dto.getId());
        if (Objects.isNull(en)) return QCUnifyReturnValue.Warn("相关方人员的修改id不存在");

        //3、验证单位id
        if (!isUnitExists(dto.getUnitid())) return QCUnifyReturnValue.Warn("相关方人员的修改的单位不存在");

        //4、验证身份证
        if (StringUtils.isNotBlank(dto.getIdnumber())) {
            if (hasIdnumberExist(dto.getIdnumber(), dto.getId())) {
                return QCUnifyReturnValue.Warn("相关方人员的身份证信息已存在");
            }
        }

        //5、手机号验证
        if (StringUtils.isNotBlank(dto.getPhone())) {
            if (hasPhoneExist(dto.getPhone(), dto.getId())) {
                return QCUnifyReturnValue.Warn("相关方人员的手机号信息已存在");
            }
        }

        EhsEpibolyPerson entity = EhsEpibolyPersonMapper.MAPPER.dtoToEntity(dto);
        if (repository.updateById(entity) < 0x1) {
            return QCUnifyReturnValue.Warn("相关方人员的修改信息失败");
        }
        return QCUnifyReturnValue.Success();
    }

    /**
     * 删除指定的相关人员的id
     * @param id 指定的相关人员id
     * @return 成功返回null, 失败返回错误或提示信息
     */
    public String delete(String id) {
        if (repository.deleteById(id) < 0x1) {
            return QCUnifyReturnValue.Warn("删除的相关方人员不存在");
        }
        return QCUnifyReturnValue.Success();
    }

    /**
     * 指定相关人员的状态，添加为黑名单列表
     * @param id 指定的相关人员id
     * @return 成功返回null, 失败返回错误或提示信息
     */
    public String addToBlackList(String id) {
        //1、判断id是否存在
        EhsEpibolyPerson en = repository.selectById(id);
        if (Objects.isNull(en)) return QCUnifyReturnValue.Warn("相关方人员不存在");

        //2、判断是否是黑名单
        if (en.getStatus() == EhsEpibolyStatusEnum.BLACKLIST) {
            return QCUnifyReturnValue.Warn("相关方人员已是黑名单");
        }

        //3、设置为黑名单
        LambdaUpdateWrapper<EhsEpibolyPerson> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(EhsEpibolyPerson::getId, id);
        wrapper.set(EhsEpibolyPerson::getStatus, EhsEpibolyStatusEnum.BLACKLIST);
        if (repository.update(null, wrapper) < 0x1) {
            return QCUnifyReturnValue.Warn("相关方人员的修改信息失败");
        }
        return QCUnifyReturnValue.Success();
    }


    /**
     * 判断身份证信息是否存在
     * @param idnumber  身份证号
     * @param excludeId 需要排除的id(可以为null,表示不排除)
     * @return boolean
     */
    boolean hasIdnumberExist(String idnumber, String excludeId) {
        LambdaQueryWrapper<EhsEpibolyPerson> wrapper = new LambdaQueryWrapper<>();
        //1、查找手机号
        wrapper.eq(EhsEpibolyPerson::getIdnumber, idnumber);

        //2、如果提供了需要排除的ID,则添加不等于条件
        if (StringUtils.isNotBlank(excludeId)) {
            wrapper.ne(EhsEpibolyPerson::getId, excludeId);
        }
        EhsEpibolyPerson en = repository.selectOne(wrapper);
        if (Objects.isNull(en)) {
            return false;
        }
        return true;
    }

    /**
     * 判断手机号是否存在
     * @param phone
     * @param excludeId
     * @return
     */
    boolean hasPhoneExist(String phone, String excludeId) {
        LambdaQueryWrapper<EhsEpibolyPerson> wrapper = new LambdaQueryWrapper<>();
        //1、查询手机号
        wrapper.eq(EhsEpibolyPerson::getPhone, phone);

        //2、如果提供需要排出的id，则添加不等于条件
        if (StringUtils.isNotBlank(excludeId)) {
            wrapper.ne(EhsEpibolyPerson::getId, excludeId);
        }
        EhsEpibolyPerson en = repository.selectOne(wrapper);
        if (Objects.isNull(en)) {
            return false;
        }
        return true;
    }

    /**
     * 验证单位
     * @param unitId 通过单位id
     * @return boolean
     */
    boolean isUnitExists(String unitId) {
        LambdaQueryWrapper<EhsEpibolyUnit> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsEpibolyUnit::getUnitid, unitId);
        EhsEpibolyUnit unit = unitRepository.selectOne(wrapper);
        if (Objects.isNull(unit)) {
            return false;
        }
        return true;
    }


}
